repeat 4 [ “repite 4 veces, una por cada lado”

forward 100, “camina 100 pasos, que será la longitud de cada lado”

turnleft 90 “gira a la izquierda 90 grados”

]

Fíjate, en sistemas Windows para ejecutar el programa que hemos creado, basta con escribir la orden:

Nombredeprograma.exe

En cambio en GNU/Linux, primero tendremos que dar permisos de ejecución sobre el archivo creado y posteriormente ejecutar la orden:

./Nombredelprograma

gcc -o main.o factorial.c main.c

./main.o

gcc -c -o fuente.o fuente.c

ar cr miLibreria.a factorial.o primo.o

gcc –Wall main.c miLibreria.a –o main.o

./main.o

Observarás que la última orden gcc tiene la opción Wall, esta opción sirve para indicar al compilador que nos avise cuando haya errores o avisos. Un error impide la ejecución del programa, un aviso nos indica que el compilador ha detectado algo extraño y que puede llevar a una ejecución no deseada de nuestro programa.

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/joe

gcc –c –fPIC factorial.c –o factorial.o

gcc –c –fPIC primo.c –o primo.o

gcc -shared -fPIC -o nombreLibreria.so fuente1.o fuente2.o

gcc –Wall main.c –o main.o miLibreria.so

./main.o

Existen dos clases fundamentales. La primera es MiProyectoApp que hereda de wxApp y modela nuestra aplicación en su conjunto. Observa la cabecera de la aplicación que ha sido creado por Code::Blocks utilizando nuestras indicaciones en el asistente.

/***************************************************************

* Name: MiProyectoApp.h

* Purpose: Defines Application Class

* Author: joe (pasatelinux@gmail.com)

* Created: 2009-05-31

* Copyright: joe (http://quickandhandytips.com)

* License: GPL.

**************************************************************/

#ifndef MIPROYECTOAPP_H

#define MIPROYECTOAPP_H

#include <wx/app.h>

class MiProyectoApp : public wxApp

{

public:

virtual bool OnInit();

};

#endif // MIPROYECTOAPP_H

* Name: MiProyectoApp.cpp

* Purpose: Code for Application Class

* Author: joe (pasatelinux@gmail.com)

* Created: 2009-05-31

* Copyright: joe (http://quickandhandytips.com)

* License: GPL.

**************************************************************/

#ifdef WX_PRECOMP

#include "wx_pch.h"

#endif

#ifdef __BORLANDC__

#pragma hdrstop

#endif //__BORLANDC__

#include "MiProyectoApp.h"

#include "MiProyectoMain.h"

#include <wx/panel.h>

IMPLEMENT_APP(MiProyectoApp);

bool MiProyectoApp::OnInit()

{

/* Estas son las líneas más importantes de esta clase, creamos un objeto de tipo MiProyectoFrame. Este último será nuestro objeto encargado de la gestión de la GUI o interfaz de usuario. Nuestra clase MiProyectoFrame heredará de wxFrame que es la clase que modela las ventanas cuyo tamaño y posición pueden (y habitualmente son) cambiadas por el usuario. Típicamente tienen bordes, barra de título y opcionalmente barras de menú y estado.

El título de la ventana principal es “Mi Proyecto con wxWidgets” y debes llamar al método Show para poder visualizarla. */

MiProyectoFrame* frame = new MiProyectoFrame(0L, _("Mi Proyecto con wxWidgets"));

frame->Show();

return true;

}

/* Esta es la segunda clase de nuestro proyecto, MiProyectoFrame se encuentra definida e implementada en los ficheros MiProyectoMain.h y MiProyectoMain.cpp */

/***************************************************************

* Name: MiProyectoMain.h

* Purpose: Defines Application Frame

* Author: joe (pasatelinux@gmail.com)

* Created: 2009-05-31

* Copyright: joe (http://quickandhandytips.com)

* License:

**************************************************************/

#ifndef MIPROYECTOMAIN_H

#define MIPROYECTOMAIN_H

#ifndef WX_PRECOMP

#include <wx/wx.h>

#endif

#include "MiProyectoApp.h"

/* Tal como indicamos nuestra clase hereda de wxFrame*/

class MiProyectoFrame: public wxFrame

{

public:

MiProyectoFrame(wxFrame *frame, const wxString& title);

~MiProyectoFrame();

/* En nuestra ventana debemos definir como atributo público miTextCtrl del tipo wxTextCtrl. Se trata de un control que permite visualizar o editar textos y que puede tener una o varias líneas. Por supuesto con wxWidgets podemos tener muchos más controles: botones (wxButton), botones con imágenes (wxBitmapButton), calendarios (wxCalendarCtrl), visualizadores HTML (wxSimpleHtmlListBox), etiquetas (wxStaticText), etc. */

wxTextCtrl *miTextCtrl;

private:

/* Como métodos privados tendremos los manejadores de los eventos asociados a las entradas de menú. */

void OnClose(wxCloseEvent& event);

void OnQuit(wxCommandEvent& event);

void OnAbout(wxCommandEvent& event);

void OnEdit(wxCommandEvent& event);

void OnOpen(wxCommandEvent& event);

void OnPreferences(wxCommandEvent& event);

DECLARE_EVENT_TABLE()

};

#endif // MIPROYECTOMAIN_H

/* El último archivo que definimos es MiProyectoMain.cpp, se trata del fichero donde se encuentra la implementación de la funcionalidad de nuestra ventana principal*/

/***************************************************************

* Name: MiProyectoMain.cpp

* Purpose: Code for Application Frame

* Author: joe (pasatelinux@gmail.com)

* Created: 2009-05-31

* Copyright: joe (http://quickandhandytips.com)

* License:

**************************************************************/

#ifdef WX_PRECOMP

#include "wx_pch.h"

#endif

#ifdef __BORLANDC__

#pragma hdrstop

#endif //__BORLANDC__

#include "MiProyectoMain.h"

/* Fíjate en los diferentes includes que tenemos que introducir para poder utilizar los diferentes componetes de wxWidgets. Por ejemplo, aboutdlg.h nos permite mostrar la ventana modal con información acerca de los autores. */

#include <wx/aboutdlg.h>

#include <wx/icon.h>

#include <wx/fontdlg.h>

#include <wx/colordlg.h>

/*El código que viene a continuación es bastante “prescindible”, sólo debes fijarte en ….*/

//helper functions

enum wxbuildinfoformat {

short_f, long_f };

wxString wxbuildinfo(wxbuildinfoformat format)

{

wxString wxbuild(wxVERSION_STRING);

if (format == long_f )

{

#if defined(__WXMSW__)

wxbuild << _T("-Windows");

#elif defined(__WXMAC__)

wxbuild << _T("-Mac");

#elif defined(__UNIX__)

wxbuild << _T("-Linux");

#endif

#if wxUSE_UNICODE

wxbuild << _T("-Unicode build");

#else

wxbuild << _T("-ANSI build");

#endif // wxUSE_UNICODE

}

return wxbuild;

}

BEGIN_EVENT_TABLE(MiProyectoFrame, wxFrame)

/* … esta línea, donde Code::Blocks (este código es suyo) indica que el método OnClose responde al evento cerrar la ventana, es decir, pulsar sobre la X de la ventana */

EVT_CLOSE(MiProyectoFrame: :OnClose)

END_EVENT_TABLE()

/* A partir de ahora definimos el constructor de nuestra ventana principal. Observa cómo realiza una llamada al constructor de la clase base wxFrame. */

MiProyectoFrame::MiProyectoFrame(wxFrame *frame, const wxString& title)

: wxFrame(frame, -1, title)

{

#if wxUSE_MENUS

// Lo primero que realizamos será crear la barra de menú.

wxMenuBar* mbar = new wxMenuBar();

/* A continuación, creamos la primera entrada de menú fileMenu, fíjate cómo tiene una cadena wxString como argumento. wxMenu representa una lista de elementos de los cuales uno podrá ser seleccionado por el usuario. */

wxMenu* fileMenu = new wxMenu(wxT(""));

/* Mediante el método Append podemos añadir un ítem al menú. Tenemos como argumentos: un identificador (p.e. wxID_OPEN), una cadena que será la que el usuario podrá visualizar al desplegar el menú fileMenu y una tercera cadena que servirá para mostrar una ayuda contextual en la barra de estado. En este caso, el identificador wxID_OPEN es una constante reservada y definirá por nosotros una entrada de menú con el típico icono y las teclas aceleradoras Ctrl, O. */

fileMenu->Append(wxID_OPEN, wxT("Abrir"), wxT("Abrir fichero"));

/* Definimos otra entrada, Salir de la misma forma */

fileMenu->Append(wxID_EXIT, wxT("Salir"), wxT("Salir de la aplicación"));

/* Agregamos el menú fileMenu a la barra de menús. */

mbar->Append(fileMenu, _("&Archivo"));

/* De modo análogo a lo anteriormente explicado definimos dos menús: editMenu y helpMenu. El primero incluirá: Editar la fuente y Color de la fuente, el segundo, el típico Acerca. */

wxMenu* editMenu = new wxMenu(_T(""));

editMenu->Append(wxID_EDIT, wxT("&Editar la fuente"), wxT("Modifica la fuente"));

editMenu->Append(wxID_PREFERENCES, wxT("Color de la fuente"), wxT("Modifica el color de la fuente"));

mbar->Append(editMenu,_("&Edita"));

wxMenu* helpMenu = new wxMenu(wxT(""));

helpMenu->Append(wxID_ABOUT, wxT("&Acerca\tF1"), wxT("Muestra informacion sobre la aplicacion"));

mbar->Append(helpMenu, wxT("&Ayuda"));

/* Un método que hereda nuestra clase MiProyectoFrame de wxFrame es SetMenuBar que indica a la ventana que muestre la barra de menú que se le pasa como parámetro.*/

SetMenuBar(mbar);

#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR

/* Otro método que también heredamos de wxFrame es CreateStatusBar que crea una barra de estado (con 2 campos) en la parte inferior de la ventana. */

CreateStatusBar(2);

/* Mostramos en dicha barra de estado la cadena “Mi proyecto con Code::Blocks!” en el primer campo.*/

SetStatusText(_("Mi Proyecto con Code::Blocks!"),0);

SetStatusText(wxbuildinfo(short_f), 1);

#endif // wxUSE_STATUSBAR

/* Ahora indicamos que eventos serán atendidos y cuáles serán sus manejadores. Así por ejemplo, el identificador de wxID_EXIT, que representa el elemento de menú “Salir” tiene un evento wxEVT_COMMAND_MENU_SELECTED, es decir, elemento de menú seleccionado. Dicho evento será atendido por OnQuit. Recuerda que debes haber definido el prototipo en MiProyectoMain.h */

Connect(wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MiProyectoFrame::OnQuit));

Connect(wxID_OPEN, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MiProyectoFrame::OnOpen));

Connect(wxID_EDIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MiProyectoFrame::OnEdit));

Connect(wxID_PREFERENCES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MiProyectoFrame::OnPreferences));

Connect(wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MiProyectoFrame::OnAbout));

/* Para acabar el constructor de nuestra ventana principal, creamos nuestro control de texto multilínea, observa la constante wxTE_MULTILINE. Su ventana padre es nuestro marco MiProyectoFrame (this) y el -1 que le sigue indica al compilador que adopte el identificador para nuestro control por defecto. */

miTextCtrl = new wxTextCtrl(this, -1, wxT(""), wxPoint(-1, -1), wxSize(-1, -1), wxTE_MULTILINE);

}

/* En nuestro caso el destructor no realiza nada */

MiProyectoFrame::~MiProyectoFrame()

{

}

/* Este es el manejador relativo a la entrada de menú Color de la fuente */

void MiProyectoFrame::OnPreferences(wxCommandEvent &event)

{

/* Definimos un objeto de la clase wxColourData donde podremos por ejemplo indicar el color que deseamos se seleccione por defecto con SetColour. */

wxColourData datosColor;

// En nuestro caso, sólo indicaremos que permita al usuario seleccionar cualquier color

datosColor.SetChooseFull(true);

/* Creamos un objeto de la clase wxColourDialog que implementa la ventana de diálogo que permite al usuario seleccionar un color. */

wxColourDialog dialogoColor(this, &datosColor);

/* Mostramos dicha ventana y si el usuario hace clic en el botón Aceptar …*/

if (dialogoColor.ShowModal() == wxID_OK)

{

/* … recuperamos la información relativa a lo que el usuario ha seleccionado, en particular en colorSeleccionado se encuentra su color preferido. Observa que wxColour es la clase que representa a un color en wxWidgets. */

wxColourData datosRespuesta = dialogoColor.GetColourData();

wxColour colorSeleccionado = datosRespuesta.GetColour();

/* Cambiamos el color de fondo del control de texto de acorde con las preferencias del usuario. */

miTextCtrl->SetBackgroundColour(colorSeleccionado);

}

/* Si el usuario pulsa Cancelar, no hacemos nada.*/

}

/* Este es el manejador relativo a la entrada de menú Abrir */

void MiProyectoFrame::OnOpen(wxCommandEvent &event)

{

/* Observa la similitud con lo realizado previamente. Creamos un objeto wxFileDialog que representa el cuadro de diálogo que permite al usuario seleccionar un fichero.*/

wxFileDialog * dialogoAbrirFichero = new wxFileDialog(this);

/* Cambiamos el título para que muestre Abrir fichero en la barra de título. */

dialogoAbrirFichero->SetMessage(wxT("Abrir fichero"));

/* Si el usuario ha hecho clic sobre Aceptar… */

if (dialogoAbrirFichero->ShowModal() == wxID_OK){

/* … recuperamos la información del diálogo, en nuestro caso, el path o la ruta del archivo seleccionado */

wxString nombreFichero = dialogoAbrirFichero->GetPath();

/* Mostramos la información Abriendo… nombre del fichero en la barra de estado*/

SetStatusText(wxT("Abriendo..." + nombreFichero),0);

/* Abrimos el archivo y lo visualizamos en nuestro control de texto. */

miTextCtrl->LoadFile(nombreFichero);

}

}

/* Manejador de eventos creado por Code::Blocks para responder al evento cerrar ventana causado al pulsar la X, Cerrar. */

void MiProyectoFrame::OnClose(wxCloseEvent &event)

{

/* Es una llamada al método Destroy de wxWindow que destruye la ventana de forma segura. Fíjate que MiProyectoFrame hereda de wxFrame el cual a su vez hereda de wxWindow. */

Destroy();

}

/* Este es el manejador relativo a la entrada de menú Salir */

void MiProyectoFrame::OnQuit(wxCommandEvent &event)

{

Destroy();

}

/* Manejador relativo a la entrada de menú Editar la fuente. */

void MiProyectoFrame::OnEdit(wxCommandEvent &event)

{

/* Creamos un objeto wxFontDialog que es la clase encargada de los diálogos de selección de fuente. */

wxFontDialog *dialogoFuente = new wxFontDialog(this);

/* Muestra dicho cuadro de diálogo y si el usuario selecciona Aceptar… */

if (dialogoFuente->ShowModal() == wxID_OK) {

/* … modificamos la fuente de nuestro control de texto conforme a las especificaciones del usuario. */

miTextCtrl->SetFont(dialogoFuente->GetFontData().GetChosenFont());

/* Mostramos el mensaje Cambiamos la fuente, seguido de la descripción de la fuente en la barra de estado. */

SetStatusText(wxT("Cambiamos la fuente" + dialogoFuente->GetFontData().GetChosenFont().GetNativeFontInfoUserDesc()),0);

}

}

/* Manejador relativo a la entrada de menú Acerca. */

void MiProyectoFrame::OnAbout(wxCommandEvent &event)

{

/* Utilizamos la clase wxAboutDialogInfo que alberga toda la información que se mostrará en la ventana de diálogo estándar Acerca de cuándo se invoque con wxAboutBox*/

wxAboutDialogInfo my_info;

/* Con el método AddDeveloper, añadimos el nombre/nombres de los programadores que han diseñado el proyecto y que se mostrarán al hacer clic en el botón Créditos, pestaña Escrito por. */

my_info.AddDeveloper(_("Máximo Núñez y Fco. Javier Sánchez"));

/* En el caso del método AddTranslator, se trata de proporcionar el nombre de los traductores. Se visualiza con Créditos, Traducido por. */

my_info.AddTranslator(_("John Smith"));

/* Las siguientes llamadas son auto explicativas: nombre de las personas encargadas de la documentación, versión, nombre de la aplicación, descripción, Web de los autores y licencia.*/

my_info.AddDocWriter(_("Marta Jiménez"));

my_info.SetVersion(wxT("0.1"));

my_info.SetName(_("Mi Proyecto"));

my_info.SetDescription(_("Probando Code::Blocks"));

my_info.SetWebSite(wxT("http://quickandhandytips.com"));

my_info.SetLicence(_("GPL"));

/* Mostramos la ventana de diálogo con la información alojada en my_info. */

wxAboutBox(my_info);

}

Considera que si programas en Linux existen otras alternativas mejores a Windows Forms, léase GTK.

using System;

using System.Windows.Forms;

using System.Drawing;

namespace HolaMonoDevelop

{

class MainClass

{

public static void Main()

{

//Creamos un objeto formulario

Form miForm = new Form();

//Cambiamos la propiedad text, para que se muestre un título personalizado

miForm.Text = "Mi Windows Forms en Ubuntu";

miForm.Cursor = Cursors.Arrow;

//Añadimos el manejador del evento Paint.

miForm.Paint += HandlePaint;

Application.Run(miForm);

}

static void HandlePaint(object sender, PaintEventArgs e)

{

/*Concatenamos a “Hola Mono“ un bienvenido al usuario del sistema, el cual lo hemos recuperado llamando al método UserName de la clase SystemInformation, información del sistema. */

String cadena = "Hola Mono. Bienvenido " + SystemInformation.UserName;

/* Dibujamos una cadena y una línea, con sendas llamadas al objeto Graphics: DrawString y DrawLine */

e.Graphics.DrawString(cadena, new Font("Times New Roman", 16, FontStyle.Bold), Brushes.Black, 10,0);

e.Graphics.DrawLine(new Pen(Brushes.Red), 10, 30, 270, 30);

}

}

}